using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("CardBackManager")]
	public class CardBackManager : MonoBehaviour
	{
		[Attribute38("CardBackManager.LoadCardBackData")]
		public class LoadCardBackData : MonoClass
		{
			public int m_CardBackIndex => method_2<int>("m_CardBackIndex");

			public GameObject m_GameObject => method_3<GameObject>("m_GameObject");

			public CardBack m_CardBack => method_3<CardBack>("m_CardBack");

			public string m_Name => method_4("m_Name");

			public string m_Path => method_4("m_Path");

			public bool m_FriendlySide => method_2<bool>("m_FriendlySide");

			public bool m_Unlit => method_2<bool>("m_Unlit");

			public LoadCardBackData(IntPtr address, string className)
				: base(address, className)
			{
			}

			public LoadCardBackData(IntPtr address)
				: this(address, "LoadCardBackData")
			{
			}
		}

		[Attribute38("CardBackManager.OwnedCardBack")]
		public class OwnedCardBack : MonoClass
		{
			public int m_cardBackId => method_2<int>("m_cardBackId");

			public bool m_owned => method_2<bool>("m_owned");

			public int m_sortOrder => method_2<int>("m_sortOrder");

			public int m_sortCategory => method_2<int>("m_sortCategory");

			public long m_seasonId => method_2<long>("m_seasonId");

			public OwnedCardBack(IntPtr address, string className)
				: base(address, className)
			{
			}

			public OwnedCardBack(IntPtr address)
				: this(address, "OwnedCardBack")
			{
			}
		}

		public CardBack m_DefaultCardBack => method_3<CardBack>("m_DefaultCardBack");

		public CardBack m_FriendlyCardBack => method_3<CardBack>("m_FriendlyCardBack");

		public string m_FriendlyCardBackName => method_4("m_FriendlyCardBackName");

		public bool m_isFriendlyLoading => method_2<bool>("m_isFriendlyLoading");

		public CardBack m_OpponentCardBack => method_3<CardBack>("m_OpponentCardBack");

		public string m_OpponentCardBackName => method_4("m_OpponentCardBackName");

		public bool m_isOpponentLoading => method_2<bool>("m_isOpponentLoading");

		public bool m_ResetDefaultRegistered => method_2<bool>("m_ResetDefaultRegistered");

		public bool m_DefaultCardBackChangeListenerRegistered => method_2<bool>("m_DefaultCardBackChangeListenerRegistered");

		public string m_searchText => method_4("m_searchText");

		public CardBackManager(IntPtr address, string className)
			: base(address, className)
		{
		}

		public CardBackManager(IntPtr address)
			: this(address, "CardBackManager")
		{
		}

		public static CardBackManager Get()
		{
			return MonoClass.smethod_15<CardBackManager>(TritonHs.MainAssemblyPath, "", "CardBackManager", "Get", Array.Empty<object>());
		}

		public void Awake()
		{
			method_8("Awake");
		}

		public void OnDestroy()
		{
			method_8("OnDestroy");
		}

		public void Start()
		{
			method_8("Start");
		}

		public void WillReset()
		{
			method_8("WillReset");
		}

		public void SetSearchText(string searchText)
		{
			method_8("SetSearchText", searchText);
		}

		public int GetDeckCardBackID(long deck)
		{
			return method_11<int>("GetDeckCardBackID", new object[1] { deck });
		}

		public CardBack GetFriendlyCardBack()
		{
			return method_14<CardBack>("GetFriendlyCardBack", Array.Empty<object>());
		}

		public CardBack GetOpponentCardBack()
		{
			return method_14<CardBack>("GetOpponentCardBack", Array.Empty<object>());
		}

		public void UpdateAllCardBacks()
		{
			method_8("UpdateAllCardBacks");
		}

		public void SetGameCardBackIDs(int friendlyCardBackID, int opponentCardBackID)
		{
			method_8("SetGameCardBackIDs", friendlyCardBackID, opponentCardBackID);
		}

		public LoadCardBackData LoadCardBackByIndex(int cardBackIdx, bool unlit, string actorName)
		{
			return method_15<LoadCardBackData>("LoadCardBackByIndex", new Class276.Enum20[3]
			{
				Class276.Enum20.I4,
				Class276.Enum20.Boolean,
				Class276.Enum20.String
			}, new object[3] { cardBackIdx, unlit, actorName });
		}

		public void AddNewCardBack(int cardBackID)
		{
			method_8("AddNewCardBack", cardBackID);
		}

		public int GetDefaultCardBackID()
		{
			return method_11<int>("GetDefaultCardBackID", Array.Empty<object>());
		}

		public string GetCardBackName(int cardBackId)
		{
			return method_13("GetCardBackName", cardBackId);
		}

		public int GetNumCardBacksOwned()
		{
			return method_11<int>("GetNumCardBacksOwned", Array.Empty<object>());
		}

		public bool IsCardBackOwned(int cardBackID)
		{
			return method_11<bool>("IsCardBackOwned", new object[1] { cardBackID });
		}

		public bool IsCardBackEnabled(int cardBackID)
		{
			return method_11<bool>("IsCardBackEnabled", new object[1] { cardBackID });
		}

		public List<CardBackData> GetEnabledCardBacks()
		{
			return method_14<Class271<CardBackData>>("GetEnabledCardBacks", Array.Empty<object>())?.method_25();
		}

		public List<OwnedCardBack> GetOrderedEnabledCardBacks(bool checkOwned)
		{
			return method_14<Class271<OwnedCardBack>>("GetOrderedEnabledCardBacks", new object[1] { checkOwned })?.method_25();
		}

		public int GetNumEnabledCardBacks()
		{
			return method_11<int>("GetNumEnabledCardBacks", Array.Empty<object>());
		}

		public void SetCardBackTexture(Renderer renderer, int matIdx, bool friendlySide)
		{
			method_8("SetCardBackTexture", renderer, matIdx, friendlySide);
		}

		public void UpdateCardBack(Actor actor, CardBack cardBack)
		{
			method_9("UpdateCardBack", new Class276.Enum20[2]
			{
				Class276.Enum20.Class,
				Class276.Enum20.Class
			}, actor, cardBack);
		}

		public void UpdateCardBackWithInternalCardBack(Actor actor)
		{
			method_8("UpdateCardBackWithInternalCardBack", actor);
		}

		public void UpdateCardBack(GameObject go, bool friendlySide)
		{
			method_9("UpdateCardBack", new Class276.Enum20[2]
			{
				Class276.Enum20.Class,
				Class276.Enum20.Boolean
			}, go, friendlySide);
		}

		public void UpdateDeck(GameObject go, bool friendlySide)
		{
			method_8("UpdateDeck", go, friendlySide);
		}

		public void UpdateDragEffect(GameObject go, bool friendlySide)
		{
			method_8("UpdateDragEffect", go, friendlySide);
		}

		public bool IsActorFriendly(Actor actor)
		{
			return method_11<bool>("IsActorFriendly", new object[1] { actor });
		}

		public CardBack GetCardBack(Actor actor)
		{
			return method_14<CardBack>("GetCardBack", new object[1] { actor });
		}

		public void InitCardBacks()
		{
			method_8("InitCardBacks");
		}

		public void InitCardBackData()
		{
			method_8("InitCardBackData");
		}

		public void SetTexture(Renderer renderer, int matIdx, bool friendlySide)
		{
			method_8("SetTexture", renderer, matIdx, friendlySide);
		}

		public void SetCardBack(GameObject go, bool friendlySide)
		{
			method_9("SetCardBack", new Class276.Enum20[2]
			{
				Class276.Enum20.Class,
				Class276.Enum20.Boolean
			}, go, friendlySide);
		}

		public void SetCardBack(GameObject go, CardBack cardBack)
		{
			method_9("SetCardBack", new Class276.Enum20[2]
			{
				Class276.Enum20.Class,
				Class276.Enum20.Class
			}, go, cardBack);
		}

		public void SetCardBack(GameObject go, CardBack cardBack, bool unlit)
		{
			method_9("SetCardBack", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.Class,
				Class276.Enum20.Boolean
			}, go, cardBack, unlit);
		}

		public void SetDragEffects(GameObject go, bool friendlySide)
		{
			method_8("SetDragEffects", go, friendlySide);
		}

		public void SetDeckCardBack(GameObject go, bool friendlySide)
		{
			method_8("SetDeckCardBack", go, friendlySide);
		}

		public void OnCheatOptionChanged(Option option, object prevValue, bool existed, object userData)
		{
			method_8("OnCheatOptionChanged", option, prevValue, existed, userData);
		}

		public void NetCache_OnNetCacheCardBacksUpdated()
		{
			method_8("NetCache_OnNetCacheCardBacksUpdated");
		}

		public void LoadCardBack(AssetReference assetRef, bool friendlySide)
		{
			method_8("LoadCardBack", assetRef, friendlySide);
		}

		public void OnCardBackLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnCardBackLoaded", assetRef, go, callbackData);
		}

		public void LoadDefaultCardBack()
		{
			method_8("LoadDefaultCardBack");
		}

		public void OnDefaultCardBackLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnDefaultCardBackLoaded", assetRef, go, callbackData);
		}

		public void FailedLoad(bool friendlySide)
		{
			method_8("FailedLoad", friendlySide);
		}

		public void OnHiddenActorLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnHiddenActorLoaded", assetRef, go, callbackData);
		}

		public void OnHiddenActorCardBackLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnHiddenActorCardBackLoaded", assetRef, go, callbackData);
		}

		public int GetValidCardBackID(int cardBackID)
		{
			return method_11<int>("GetValidCardBackID", new object[1] { cardBackID });
		}

		public void OnDefaultCardBackChanged(int defaultCardBackID, object userData)
		{
			method_8("OnDefaultCardBackChanged", defaultCardBackID, userData);
		}

		public void OnSceneChangeResetDefaultCardBack(SceneMgr.Mode mode, PegasusScene scene, object userData)
		{
			method_8("OnSceneChangeResetDefaultCardBack", mode, scene, userData);
		}
	}
}
